public class RecursiveWork {
    /**
     * @name 递归求解汉诺塔
     * @param start   起始位置
     * @param transit 中转位置
     * @param end     目标位置
     * **/
    public static void hanio(char start, char transit, char end, int number) {
        if (1 == number) {//只有一个盘子
            //直接将盘纸移动到C
            move(start, end);
            return;
        }else {//盘子大于1个
            //此时 transit 是目标位置；而 end 是中转位置
            hanio(start, end, transit, number - 1);//借助 C 将 n-1 个盘子移动到 B 上
            move(start, end);
            //此时 start 是中转位置，而end是目标位置
            hanio(transit, start, end, number - 1);//借助 A 把 n-1 个盘子移动到C上
        }
    }
    /**
     * @param start     起始位置
     * @param transit   目标位置
     **/
    public static void move(char start, char transit) {
        System.out.print(start +"->"+ transit + " ");
    }

    public static void main(String[] args) {
        hanio('A', 'B', 'C', 1);
        System.out.println();
        hanio('A', 'B', 'C', 2);
        System.out.println();
        hanio('A', 'B', 'C', 3);
        System.out.println();
        hanio('A', 'B', 'C', 4);
    }

    /**
     * @projecct 斐波那契数列递归
     * **/
    public static int fib(int n) {
        if (n == 1 || n == 2) {
            return 1;
        }
        return fib(n - 1) + fib(n - 2);
    }

    public static void main6(String[] args) {
        System.out.println(fib(1));
        System.out.println(fib(2));
        System.out.println(fib(3));
        System.out.println(fib(4));
        System.out.println(fib(5));
        System.out.println(fib(6));
    }
    /**
     * @project 递归的实现过程（阶乘）
     * **/
    public static int factor(int n) {
        System.out.println("函数开始, n = " + n);
        if (n == 1) {
            System.out.println("函数结束, n = 1 ret = 1");
            return 1;
        }
        int ret = n * factor(n - 1);
        System.out.println("函数结束, n = " + n + " ret = " + ret);
        return ret;
    }

    public static void main5(String[] args) {
        int n = 3;
        int ret = factor(n);
        System.out.println("ret = " + ret);
    }
    /**
     * @project 1~10的和
     * **/
    public static int func(int n) {
        if (n == 1) {
            return 1;
        }else {
            return n + func(n - 1);
        }
    }

    public static void main4(String[] args) {
        int num = 10;
        int ret = func(num);
        System.out.println(ret);
    }
    /**
     * @project 每一位的和
     * **/
    public static int sum(int num) {
        if (num <= 9) {
            return num;
        }else {
            return num % 10 + sum(num / 10);
        }
    }

    public static void main3(String[] args) {
        int n = 123;
        int ret = sum(n);
        System.out.println(ret);
    }
    /**
     * @project 打印每一位
     * **/
    public static void add(int n) {
        if (n > 9) {
            add(n / 10);
        }
        System.out.println(n % 10);
    }

    public static void main2(String[] args) {
        int n = 123;
        add(n);
    }
    /**
     * @project n的阶乘
     */
    public static int fac(int num) {
        if (num == 1) {//1的阶乘就是1 - 直接返回1就可以
            return 1;
        } else {
            //大于1的情况
            int recur = num * fac(num - 1);
            return recur;
        }
    }

    public static void main1(String[] args) {
        int num = 3;
        int ret = fac(num);
        System.out.println(ret);
    }
}